1 active snapshot at a time is not enough for some of the uses that we will have.

For example, there is a case with nested bundles where you can have optional bundle there.
If tx inside nested optional bundle fails the nested bundle should be reverted but outer should not.

Other example could be allowing optional txs inside bundle to be thrown out on revert (instead of commiting them as reverted). Even though we decided on "if optional tx reverts we keep it reverted" but it may be the case that we change our opinion to "if optional tx reverts we discard it".

This may become important when we merge bundles.

API can look something like that.

// first you create snapshot
statedb.NewMultiTxSnapshot()

// you commit txs here

// if you dislike the results
statedb.RevertMultiTxSnapshot()

// if you are ok with results
statedb.CommitMultiTxSnapshot() // must call it!

• When you call Push new snapshot is created and added to the stack of active multi tx snapshots. New snapshot will accumulate all changes.
• When you call Revert state is reverted with the latest changes from the top level snapshot, and its popped from the list.
• When you call Commit
  1. it pops snapshots from the stack
  2. if there is another snapshot in the stack, merge all the changes of the popped one with the new head of the stack

1. that transient storage will work with efficient reverts when they are implemented. do we need to clean them from the statedb / object structure (like we clean dirty storage)
2. make sure that sbundle with backruns work. We have tests for them in the repo (they test envdiff implemenation).

Done